/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
Copyright (C) 2000-2006 Tim Angus

This file is part of Tremulous.

Tremulous is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Tremulous is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Tremulous; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#ifndef __UI_LOCAL_H__
#define __UI_LOCAL_H__

#include "../../../code/qcommon/q_shared.h"
#include "../../../code/renderer/tr_types.h"
#include "ui_public.h"
#include "../../../code/client/keycodes.h"
#include "../game/bg_public.h"
#include "ui_shared.h"

// global display context

extern vmCvar_t ui_ffa_fraglimit;
extern vmCvar_t ui_ffa_timelimit;

extern vmCvar_t ui_tourney_fraglimit;
extern vmCvar_t ui_tourney_timelimit;

extern vmCvar_t ui_team_fraglimit;
extern vmCvar_t ui_team_timelimit;
extern vmCvar_t ui_team_friendly;

extern vmCvar_t ui_ctf_capturelimit;
extern vmCvar_t ui_ctf_timelimit;
extern vmCvar_t ui_ctf_friendly;

extern vmCvar_t ui_arenasFile;
extern vmCvar_t ui_botsFile;
extern vmCvar_t ui_spScores1;
extern vmCvar_t ui_spScores2;
extern vmCvar_t ui_spScores3;
extern vmCvar_t ui_spScores4;
extern vmCvar_t ui_spScores5;
extern vmCvar_t ui_spAwards;
extern vmCvar_t ui_spVideos;
extern vmCvar_t ui_spSkill;

extern vmCvar_t ui_spSelection;

extern vmCvar_t ui_browserMaster;
extern vmCvar_t ui_browserGameType;
extern vmCvar_t ui_browserSortKey;
extern vmCvar_t ui_browserShowFull;
extern vmCvar_t ui_browserShowEmpty;

extern vmCvar_t ui_brassTime;
extern vmCvar_t ui_drawCrosshair;
extern vmCvar_t ui_drawCrosshairNames;
extern vmCvar_t ui_marks;

extern vmCvar_t ui_server1;
extern vmCvar_t ui_server2;
extern vmCvar_t ui_server3;
extern vmCvar_t ui_server4;
extern vmCvar_t ui_server5;
extern vmCvar_t ui_server6;
extern vmCvar_t ui_server7;
extern vmCvar_t ui_server8;
extern vmCvar_t ui_server9;
extern vmCvar_t ui_server10;
extern vmCvar_t ui_server11;
extern vmCvar_t ui_server12;
extern vmCvar_t ui_server13;
extern vmCvar_t ui_server14;
extern vmCvar_t ui_server15;
extern vmCvar_t ui_server16;

extern vmCvar_t ui_captureLimit;
extern vmCvar_t ui_fragLimit;
extern vmCvar_t ui_gameType;
extern vmCvar_t ui_netGameType;
extern vmCvar_t ui_actualNetGameType;
extern vmCvar_t ui_joinGameType;
extern vmCvar_t ui_netSource;
extern vmCvar_t ui_serverFilterType;
extern vmCvar_t ui_dedicated;
extern vmCvar_t ui_opponentName;
extern vmCvar_t ui_menuFiles;
extern vmCvar_t ui_currentTier;
extern vmCvar_t ui_currentMap;
extern vmCvar_t ui_currentNetMap;
extern vmCvar_t ui_mapIndex;
extern vmCvar_t ui_currentOpponent;
extern vmCvar_t ui_selectedPlayer;
extern vmCvar_t ui_selectedPlayerName;
extern vmCvar_t ui_lastServerRefresh_0;
extern vmCvar_t ui_lastServerRefresh_1;
extern vmCvar_t ui_lastServerRefresh_2;
extern vmCvar_t ui_lastServerRefresh_3;
extern vmCvar_t ui_singlePlayerActive;
extern vmCvar_t ui_scoreAccuracy;
extern vmCvar_t ui_scoreImpressives;
extern vmCvar_t ui_scoreExcellents;
extern vmCvar_t ui_scoreDefends;
extern vmCvar_t ui_scoreAssists;
extern vmCvar_t ui_scoreGauntlets;
extern vmCvar_t ui_scoreScore;
extern vmCvar_t ui_scorePerfect;
extern vmCvar_t ui_scoreTeam;
extern vmCvar_t ui_scoreBase;
extern vmCvar_t ui_scoreTimeBonus;
extern vmCvar_t ui_scoreSkillBonus;
extern vmCvar_t ui_scoreShutoutBonus;
extern vmCvar_t ui_scoreTime;
extern vmCvar_t ui_smallFont;
extern vmCvar_t ui_bigFont;
extern vmCvar_t ui_serverStatusTimeOut;

//TA: bank values
extern vmCvar_t ui_bank;


//
// ui_qmenu.c
//

#define RCOLUMN_OFFSET      ( BIGCHAR_WIDTH )
#define LCOLUMN_OFFSET      (-BIGCHAR_WIDTH )

#define SLIDER_RANGE      10
#define  MAX_EDIT_LINE      256

#define MAX_MENUDEPTH      8
#define MAX_MENUITEMS      96

#define MTYPE_NULL        0
#define MTYPE_SLIDER      1
#define MTYPE_ACTION      2
#define MTYPE_SPINCONTROL    3
#define MTYPE_FIELD        4
#define MTYPE_RADIOBUTTON    5
#define MTYPE_BITMAP      6
#define MTYPE_TEXT        7
#define MTYPE_SCROLLLIST    8
#define MTYPE_PTEXT        9
#define MTYPE_BTEXT        10

#define QMF_BLINK        0x00000001
#define QMF_SMALLFONT      0x00000002
#define QMF_LEFT_JUSTIFY    0x00000004
#define QMF_CENTER_JUSTIFY    0x00000008
#define QMF_RIGHT_JUSTIFY    0x00000010
#define QMF_NUMBERSONLY      0x00000020	// edit field is only numbers
#define QMF_HIGHLIGHT      0x00000040
#define QMF_HIGHLIGHT_IF_FOCUS  0x00000080	// steady focus
#define QMF_PULSEIFFOCUS    0x00000100	// pulse if focus
#define QMF_HASMOUSEFOCUS    0x00000200
#define QMF_NOONOFFTEXT      0x00000400
#define QMF_MOUSEONLY      0x00000800	// only mouse input allowed
#define QMF_HIDDEN        0x00001000	// skips drawing
#define QMF_GRAYED        0x00002000	// grays and disables
#define QMF_INACTIVE      0x00004000	// disables any input
#define QMF_NODEFAULTINIT    0x00008000	// skip default initialization
#define QMF_OWNERDRAW      0x00010000
#define QMF_PULSE        0x00020000
#define QMF_LOWERCASE      0x00040000	// edit field is all lower case
#define QMF_UPPERCASE      0x00080000	// edit field is all upper case
#define QMF_SILENT        0x00100000

// callback notifications
#define QM_GOTFOCUS        1
#define QM_LOSTFOCUS      2
#define QM_ACTIVATED      3

typedef struct _tag_menuframework
{
	int             cursor;
	int             cursor_prev;

	int             nitems;
	void           *items[MAX_MENUITEMS];

	void            (*draw) (void);
	                sfxHandle_t(*key) (int key);

	qboolean        wrapAround;
	qboolean        fullscreen;
	qboolean        showlogo;
} menuframework_s;

typedef struct
{
	int             type;
	const char     *name;
	int             id;
	int             x, y;
	int             left;
	int             top;
	int             right;
	int             bottom;
	menuframework_s *parent;
	int             menuPosition;
	unsigned        flags;

	void            (*callback) (void *self, int event);
	void            (*statusbar) (void *self);
	void            (*ownerdraw) (void *self);
} menucommon_s;

typedef struct
{
	int             cursor;
	int             scroll;
	int             widthInChars;
	char            buffer[MAX_EDIT_LINE];
	int             maxchars;
} mfield_t;

typedef struct
{
	menucommon_s    generic;
	mfield_t        field;
} menufield_s;

typedef struct
{
	menucommon_s    generic;

	float           minvalue;
	float           maxvalue;
	float           curvalue;

	float           range;
} menuslider_s;

typedef struct
{
	menucommon_s    generic;

	int             oldvalue;
	int             curvalue;
	int             numitems;
	int             top;

	const char    **itemnames;

	int             width;
	int             height;
	int             columns;
	int             seperation;
} menulist_s;

typedef struct
{
	menucommon_s    generic;
} menuaction_s;

typedef struct
{
	menucommon_s    generic;
	int             curvalue;
} menuradiobutton_s;

typedef struct
{
	menucommon_s    generic;
	char           *focuspic;
	char           *errorpic;
	qhandle_t       shader;
	qhandle_t       focusshader;
	int             width;
	int             height;
	float          *focuscolor;
} menubitmap_s;

typedef struct
{
	menucommon_s    generic;
	char           *string;
	int             style;
	float          *color;
} menutext_s;

extern void     Menu_Cache(void);
extern void     Menu_Focus(menucommon_s * m);
extern void     Menu_AddItem(menuframework_s * menu, void *item);
extern void     Menu_AdjustCursor(menuframework_s * menu, int dir);
extern void     Menu_Draw(menuframework_s * menu);
extern void    *Menu_ItemAtCursor(menuframework_s * m);
extern sfxHandle_t Menu_ActivateItem(menuframework_s * s, menucommon_s * item);
extern void     Menu_SetCursor(menuframework_s * s, int cursor);
extern void     Menu_SetCursorToItem(menuframework_s * m, void *ptr);
extern sfxHandle_t Menu_DefaultKey(menuframework_s * s, int key);
extern void     Bitmap_Init(menubitmap_s * b);
extern void     Bitmap_Draw(menubitmap_s * b);
extern void     ScrollList_Draw(menulist_s * l);
extern sfxHandle_t ScrollList_Key(menulist_s * l, int key);
extern sfxHandle_t menu_in_sound;
extern sfxHandle_t menu_move_sound;
extern sfxHandle_t menu_out_sound;
extern sfxHandle_t menu_buzz_sound;
extern sfxHandle_t menu_null_sound;
extern sfxHandle_t weaponChangeSound;
extern vec4_t   menu_text_color;
extern vec4_t   menu_grayed_color;
extern vec4_t   menu_dark_color;
extern vec4_t   menu_highlight_color;
extern vec4_t   menu_red_color;
extern vec4_t   menu_black_color;
extern vec4_t   menu_dim_color;
extern vec4_t   color_black;
extern vec4_t   color_white;
extern vec4_t   color_yellow;
extern vec4_t   color_blue;
extern vec4_t   color_orange;
extern vec4_t   color_red;
extern vec4_t   color_dim;
extern vec4_t   name_color;
extern vec4_t   list_color;
extern vec4_t   listbar_color;
extern vec4_t   text_color_disabled;
extern vec4_t   text_color_normal;
extern vec4_t   text_color_highlight;

extern char    *ui_medalNames[];
extern char    *ui_medalPicNames[];
extern char    *ui_medalSounds[];

//
// ui_mfield.c
//
extern void     MField_Clear(mfield_t * edit);
extern void     MField_KeyDownEvent(mfield_t * edit, int key);
extern void     MField_CharEvent(mfield_t * edit, int ch);
extern void     MField_Draw(mfield_t * edit, int x, int y, int style, vec4_t color);
extern void     MenuField_Init(menufield_s * m);
extern void     MenuField_Draw(menufield_s * f);
extern sfxHandle_t MenuField_Key(menufield_s * m, int *key);

//
// ui_main.c
//
void            UI_Report(void);
void            UI_Load(void);
void            UI_LoadMenus(const char *menuFile, qboolean reset);
void            _UI_SetActiveMenu(uiMenuCommand_t menu);
int             UI_AdjustTimeByGame(int time);
void            UI_ShowPostGame(qboolean newHigh);
void            UI_ClearScores(void);
void            UI_LoadArenas(void);

//
// ui_menu.c
//
extern void     MainMenu_Cache(void);
extern void     UI_MainMenu(void);
extern void     UI_RegisterCvars(void);
extern void     UI_UpdateCvars(void);

//
// ui_credits.c
//
extern void     UI_CreditMenu(void);

//
// ui_ingame.c
//
extern void     InGame_Cache(void);
extern void     UI_InGameMenu(void);

//
// ui_confirm.c
//
extern void     ConfirmMenu_Cache(void);
extern void     UI_ConfirmMenu(const char *question, void (*draw) (void), void (*action) (qboolean result));

//
// ui_setup.c
//
extern void     UI_SetupMenu_Cache(void);
extern void     UI_SetupMenu(void);

//
// ui_team.c
//
extern void     UI_TeamMainMenu(void);
extern void     TeamMain_Cache(void);

//
// ui_connect.c
//
extern void     UI_DrawConnectScreen(qboolean overlay);

//
// ui_controls2.c
//
extern void     UI_ControlsMenu(void);
extern void     Controls_Cache(void);

//
// ui_demo2.c
//
extern void     UI_DemosMenu(void);
extern void     Demos_Cache(void);

//
// ui_cinematics.c
//
extern void     UI_CinematicsMenu(void);
extern void     UI_CinematicsMenu_f(void);
extern void     UI_CinematicsMenu_Cache(void);

//
// ui_mods.c
//
extern void     UI_ModsMenu(void);
extern void     UI_ModsMenu_Cache(void);

//
// ui_playermodel.c
//
extern void     UI_PlayerModelMenu(void);
extern void     PlayerModel_Cache(void);

//
// ui_playersettings.c
//
extern void     UI_PlayerSettingsMenu(void);
extern void     PlayerSettings_Cache(void);

//
// ui_preferences.c
//
extern void     UI_PreferencesMenu(void);
extern void     Preferences_Cache(void);

//
// ui_specifyleague.c
//
extern void     UI_SpecifyLeagueMenu(void);
extern void     SpecifyLeague_Cache(void);

//
// ui_specifyserver.c
//
extern void     UI_SpecifyServerMenu(void);
extern void     SpecifyServer_Cache(void);

//
// ui_servers2.c
//
#define MAX_FAVORITESERVERS 16

extern void     UI_ArenaServersMenu(void);
extern void     ArenaServers_Cache(void);

//
// ui_startserver.c
//
extern void     UI_StartServerMenu(qboolean multiplayer);
extern void     StartServer_Cache(void);
extern void     ServerOptions_Cache(void);
extern void     UI_BotSelectMenu(char *bot);
extern void     UI_BotSelectMenu_Cache(void);

//
// ui_serverinfo.c
//
extern void     UI_ServerInfoMenu(void);
extern void     ServerInfo_Cache(void);

//
// ui_video.c
//
extern void     UI_GraphicsOptionsMenu(void);
extern void     GraphicsOptions_Cache(void);
extern void     DriverInfo_Cache(void);

//
// ui_players.c
//

//FIXME ripped from cg_local.h
typedef struct
{
	int             oldFrame;
	int             oldFrameTime;	// time when ->oldFrame was exactly on

	int             frame;
	int             frameTime;	// time when ->frame will be exactly on

	float           backlerp;

	float           yawAngle;
	qboolean        yawing;
	float           pitchAngle;
	qboolean        pitching;

	int             animationNumber;	// may include ANIM_TOGGLEBIT
	animation_t    *animation;
	int             animationTime;	// time when the first frame of the animation will be exact
} lerpFrame_t;

typedef struct
{
	// model info
	qhandle_t       legsModel;
	qhandle_t       legsSkin;
	lerpFrame_t     legs;

	qhandle_t       torsoModel;
	qhandle_t       torsoSkin;
	lerpFrame_t     torso;

	qhandle_t       headModel;
	qhandle_t       headSkin;

	animation_t     animations[MAX_PLAYER_TOTALANIMATIONS];

	qhandle_t       weaponModel;
	qhandle_t       barrelModel;
	qhandle_t       flashModel;
	vec3_t          flashDlightColor;
	int             muzzleFlashTime;

	// currently in use drawing parms
	vec3_t          viewAngles;
	vec3_t          moveAngles;
	weapon_t        currentWeapon;
	int             legsAnim;
	int             torsoAnim;

	// animation vars
	weapon_t        weapon;
	weapon_t        lastWeapon;
	weapon_t        pendingWeapon;
	int             weaponTimer;
	int             pendingLegsAnim;
	int             torsoAnimationTimer;

	int             pendingTorsoAnim;
	int             legsAnimationTimer;

	qboolean        chat;
	qboolean        newModel;

	qboolean        barrelSpinning;
	float           barrelAngle;
	int             barrelTime;

	int             realWeapon;
} playerInfo_t;

void            UI_DrawPlayer(float x, float y, float w, float h, playerInfo_t * pi, int time);
void            UI_PlayerInfo_SetModel(playerInfo_t * pi, const char *model, const char *headmodel, char *teamName);
void            UI_PlayerInfo_SetInfo(playerInfo_t * pi, int legsAnim, int torsoAnim, vec3_t viewAngles, vec3_t moveAngles,
									  weapon_t weaponNum, qboolean chat);
qboolean        UI_RegisterClientModelname(playerInfo_t * pi, const char *modelSkinName, const char *headName,
										   const char *teamName);

//
// ui_atoms.c
//
// this is only used in the old ui, the new ui has it's own version
typedef struct
{
	int             frametime;
	int             realtime;
	int             cursorx;
	int             cursory;
	glconfig_t      glconfig;
	glconfig2_t      glconfig2;
	qboolean        debug;
	qhandle_t       whiteShader;
	qhandle_t       charset;
	qhandle_t       charsetProp;
	qhandle_t       charsetPropGlow;
	qhandle_t       charsetPropB;
	qhandle_t       cursor;
	qhandle_t       rb_on;
	qhandle_t       rb_off;
	float           scale;
	float           bias;
	qboolean        demoversion;
	qboolean        firstdraw;
} uiStatic_t;


// new ui stuff
#define UI_NUMFX 7
#define MAX_HEADS 64
#define MAX_ALIASES 64
#define MAX_HEADNAME  32
#define MAX_TEAMS 64
#define MAX_GAMETYPES 16
#define MAX_MAPS 128
#define MAX_SPMAPS 16
#define PLAYERS_PER_TEAM 5
#define MAX_PINGREQUESTS    32
#define MAX_ADDRESSLENGTH    64
#define MAX_HOSTNAMELENGTH    22
#define MAX_MAPNAMELENGTH    16
#define MAX_STATUSLENGTH    64
#define MAX_LISTBOXWIDTH    59
#define UI_FONT_THRESHOLD    0.1
#define MAX_DISPLAY_SERVERS    2048
#define MAX_SERVERSTATUS_LINES  128
#define MAX_SERVERSTATUS_TEXT  1024
#define MAX_FOUNDPLAYER_SERVERS  16
#define TEAM_MEMBERS 5
#define GAMES_ALL      0
#define GAMES_FFA      1
#define GAMES_TEAMPLAY    2
#define GAMES_TOURNEY    3
#define GAMES_CTF      4
#define MAPS_PER_TIER 3
#define MAX_TIERS 16
#define MAX_MODS 64
#define MAX_DEMOS 256
#define MAX_MOVIES 256
#define MAX_PLAYERMODELS 256


typedef struct
{
	const char     *name;
	const char     *imageName;
	qhandle_t       headImage;
	const char     *base;
	qboolean        active;
	int             reference;
} characterInfo;

typedef struct
{
	const char     *name;
	const char     *ai;
	const char     *action;
} aliasInfo;

typedef struct
{
	const char     *teamName;
	const char     *imageName;
	const char     *teamMembers[TEAM_MEMBERS];
	qhandle_t       teamIcon;
	qhandle_t       teamIcon_Metal;
	qhandle_t       teamIcon_Name;
	int             cinematic;
} teamInfo;

typedef struct
{
	const char     *gameType;
	int             gtEnum;
} gameTypeInfo;

typedef struct
{
	const char     *mapName;
	const char     *mapLoadName;
	const char     *imageName;
	const char     *opponentName;
	int             teamMembers;
	int             typeBits;
	int             cinematic;
	int             timeToBeat[MAX_GAMETYPES];
	qhandle_t       levelShot;
	qboolean        active;
} mapInfo;

typedef struct
{
	const char     *tierName;
	const char     *maps[MAPS_PER_TIER];
	int             gameTypes[MAPS_PER_TIER];
	qhandle_t       mapHandles[MAPS_PER_TIER];
} tierInfo;

typedef struct serverFilter_s
{
	const char     *description;
	const char     *basedir;
} serverFilter_t;

typedef struct
{
	char            adrstr[MAX_ADDRESSLENGTH];
	int             start;
} pinglist_t;


typedef struct serverStatus_s
{
	pinglist_t      pingList[MAX_PINGREQUESTS];
	int             numqueriedservers;
	int             currentping;
	int             nextpingtime;
	int             maxservers;
	int             refreshtime;
	int             numServers;
	int             sortKey;
	int             sortDir;
	int             lastCount;
	qboolean        refreshActive;
	int             currentServer;
	int             displayServers[MAX_DISPLAY_SERVERS];
	int             numDisplayServers;
	int             numPlayersOnServers;
	int             nextDisplayRefresh;
	int             nextSortTime;
	qhandle_t       currentServerPreview;
	int             currentServerCinematic;
	int             motdLen;
	int             motdWidth;
	int             motdPaintX;
	int             motdPaintX2;
	int             motdOffset;
	int             motdTime;
	char            motd[MAX_STRING_CHARS];
} serverStatus_t;


typedef struct
{
	char            adrstr[MAX_ADDRESSLENGTH];
	char            name[MAX_ADDRESSLENGTH];
	int             startTime;
	int             serverNum;
	qboolean        valid;
} pendingServer_t;

typedef struct
{
	int             num;
	pendingServer_t server[MAX_SERVERSTATUSREQUESTS];
} pendingServerStatus_t;

typedef struct
{
	char            address[MAX_ADDRESSLENGTH];
	char           *lines[MAX_SERVERSTATUS_LINES][4];
	char            text[MAX_SERVERSTATUS_TEXT];
	char            pings[MAX_CLIENTS * 3];
	int             numLines;
} serverStatusInfo_t;

typedef struct
{
	const char     *modName;
	const char     *modDescr;
} modInfo_t;

//TA: tremulous menus
#define MAX_INFOPANE_TEXT     4096
#define MAX_INFOPANE_GRAPHICS 16
#define MAX_INFOPANES         128

typedef enum
{
	INFOPANE_TOP,
	INFOPANE_BOTTOM,
	INFOPANE_LEFT,
	INFOPANE_RIGHT
} tremIPSide_t;

typedef struct
{
	qhandle_t       graphic;

	tremIPSide_t    side;
	int             offset;

	int             width, height;
} tremIPGraphic_t;

typedef struct
{
	const char     *name;
	char            text[MAX_INFOPANE_TEXT];
	int             align;

	tremIPGraphic_t graphics[MAX_INFOPANE_GRAPHICS];
	int             numGraphics;
} tremInfoPane_t;

typedef struct
{
	const char     *text;
	const char     *cmd;
	tremInfoPane_t *infopane;
} tremMenuItem_t;

//TA: tremulous menus

typedef struct
{
	displayContextDef_t uiDC;
	int             newHighScoreTime;
	int             newBestTime;
	int             showPostGameTime;
	qboolean        newHighScore;
	qboolean        demoAvailable;
	qboolean        soundHighScore;

	int             characterCount;
	int             botIndex;
	characterInfo   characterList[MAX_HEADS];

	int             aliasCount;
	aliasInfo       aliasList[MAX_ALIASES];

	int             teamCount;
	teamInfo        teamList[MAX_TEAMS];

	int             numGameTypes;
	gameTypeInfo    gameTypes[MAX_GAMETYPES];

	int             numJoinGameTypes;
	gameTypeInfo    joinGameTypes[MAX_GAMETYPES];

	int             redBlue;
	int             playerCount;
	int             myTeamCount;
	int             teamIndex;
	int             playerRefresh;
	int             playerIndex;
	int             playerNumber;
	qboolean        teamLeader;
	char            playerNames[MAX_CLIENTS][MAX_NAME_LENGTH];
	char            teamNames[MAX_CLIENTS][MAX_NAME_LENGTH];
	int             teamClientNums[MAX_CLIENTS];

	int             mapCount;
	mapInfo         mapList[MAX_MAPS];


	int             tierCount;
	tierInfo        tierList[MAX_TIERS];

	int             skillIndex;

	modInfo_t       modList[MAX_MODS];
	int             modCount;
	int             modIndex;

	const char     *demoList[MAX_DEMOS];
	int             demoCount;
	int             demoIndex;

	const char     *movieList[MAX_MOVIES];
	int             movieCount;
	int             movieIndex;
	int             previewMovie;

	tremInfoPane_t  tremInfoPanes[MAX_INFOPANES];
	int             tremInfoPaneCount;

//TA: tremulous menus
	tremMenuItem_t  tremTeamList[4];
	int             tremTeamCount;
	int             tremTeamIndex;

	tremMenuItem_t  tremAlienClassList[3];
	int             tremAlienClassCount;
	int             tremAlienClassIndex;

	tremMenuItem_t  tremHumanItemList[3];
	int             tremHumanItemCount;
	int             tremHumanItemIndex;

	tremMenuItem_t  tremHumanArmouryBuyList[32];
	int             tremHumanArmouryBuyCount;
	int             tremHumanArmouryBuyIndex;

	tremMenuItem_t  tremHumanArmourySellList[32];
	int             tremHumanArmourySellCount;
	int             tremHumanArmourySellIndex;

	tremMenuItem_t  tremAlienUpgradeList[16];
	int             tremAlienUpgradeCount;
	int             tremAlienUpgradeIndex;

	tremMenuItem_t  tremAlienBuildList[32];
	int             tremAlienBuildCount;
	int             tremAlienBuildIndex;

	tremMenuItem_t  tremHumanBuildList[32];
	int             tremHumanBuildCount;
	int             tremHumanBuildIndex;
//TA: tremulous menus

	serverStatus_t  serverStatus;

	// for the showing the status of a server
	char            serverStatusAddress[MAX_ADDRESSLENGTH];
	serverStatusInfo_t serverStatusInfo;
	int             nextServerStatusRefresh;

	// to retrieve the status of server to find a player
	pendingServerStatus_t pendingServerStatus;
	char            findPlayerName[MAX_STRING_CHARS];
	char            foundPlayerServerAddresses[MAX_FOUNDPLAYER_SERVERS][MAX_ADDRESSLENGTH];
	char            foundPlayerServerNames[MAX_FOUNDPLAYER_SERVERS][MAX_ADDRESSLENGTH];
	int             currentFoundPlayerServer;
	int             numFoundPlayerServers;
	int             nextFindPlayerRefresh;

	int             currentCrosshair;
	int             startPostGameTime;
	sfxHandle_t     newHighScoreSound;

	int             q3HeadCount;
	char            q3HeadNames[MAX_PLAYERMODELS][64];
	qhandle_t       q3HeadIcons[MAX_PLAYERMODELS];
	int             q3SelectedHead;

	int             effectsColor;

	qboolean        inGameLoad;
} uiInfo_t;

extern uiInfo_t uiInfo;


extern void     UI_Init(void);
extern void     UI_Shutdown(void);
extern void     UI_KeyEvent(int key);
extern void     UI_MouseEvent(int dx, int dy);
extern void     UI_Refresh(int realtime);
extern qboolean UI_ConsoleCommand(int realTime);
extern float    UI_ClampCvar(float min, float max, float value);
extern void     UI_DrawNamedPic(float x, float y, float width, float height, const char *picname);
extern void     UI_DrawHandlePic(float x, float y, float w, float h, qhandle_t hShader);
extern void     UI_FillRect(float x, float y, float width, float height, const float *color);
extern void     UI_DrawRect(float x, float y, float width, float height, const float *color);
extern void     UI_DrawTopBottom(float x, float y, float w, float h);
extern void     UI_DrawSides(float x, float y, float w, float h);
extern void     UI_UpdateScreen(void);
extern void     UI_SetColor(const float *rgba);
extern void     UI_LerpColor(vec4_t a, vec4_t b, vec4_t c, float t);
extern void     UI_DrawBannerString(int x, int y, const char *str, int style, vec4_t color);
extern float    UI_ProportionalSizeScale(int style);
extern void     UI_DrawProportionalString(int x, int y, const char *str, int style, vec4_t color);
extern int      UI_ProportionalStringWidth(const char *str);
extern void     UI_DrawString(int x, int y, const char *str, int style, vec4_t color);
extern void     UI_DrawChar(int x, int y, int ch, int style, vec4_t color);
extern qboolean UI_CursorInRect(int x, int y, int width, int height);
extern void     UI_AdjustFrom640(float *x, float *y, float *w, float *h);
extern void     UI_DrawTextBox(int x, int y, int width, int lines);
extern qboolean UI_IsFullscreen(void);
extern void     UI_SetActiveMenu(uiMenuCommand_t menu);
extern void     UI_PushMenu(menuframework_s * menu);
extern void     UI_PopMenu(void);
extern void     UI_ForceMenuOff(void);
extern char    *UI_Argv(int arg);
extern char    *UI_Cvar_VariableString(const char *var_name);
extern void     UI_Refresh(int time);
extern void     UI_KeyEvent(int key);
extern void     UI_StartDemoLoop(void);
extern qboolean m_entersound;
void            UI_LoadBestScores(const char *map, int game);
extern uiStatic_t uis;

//
// ui_spLevel.c
//
void            UI_SPLevelMenu_Cache(void);
void            UI_SPLevelMenu(void);
void            UI_SPLevelMenu_f(void);
void            UI_SPLevelMenu_ReInit(void);

//
// ui_spArena.c
//
void            UI_SPArena_Start(const char *arenaInfo);

//
// ui_spPostgame.c
//
void            UI_SPPostgameMenu_Cache(void);
void            UI_SPPostgameMenu_f(void);

//
// ui_spSkill.c
//
void            UI_SPSkillMenu(const char *arenaInfo);
void            UI_SPSkillMenu_Cache(void);

//
// ui_syscalls.c
//
void            trap_Print(const char *string);
void            trap_Error(const char *string);
int             trap_Milliseconds(void);
void            trap_Cvar_Register(vmCvar_t * vmCvar, const char *varName, const char *defaultValue, int flags);
void            trap_Cvar_Update(vmCvar_t * vmCvar);
void            trap_Cvar_Set(const char *var_name, const char *value);
float           trap_Cvar_VariableValue(const char *var_name);
void            trap_Cvar_VariableStringBuffer(const char *var_name, char *buffer, int bufsize);
void            trap_Cvar_SetValue(const char *var_name, float value);
void            trap_Cvar_Reset(const char *name);
void            trap_Cvar_Create(const char *var_name, const char *var_value, int flags);
void            trap_Cvar_InfoStringBuffer(int bit, char *buffer, int bufsize);
int             trap_Argc(void);
void            trap_Argv(int n, char *buffer, int bufferLength);
void            trap_Cmd_ExecuteText(int exec_when, const char *text);	// don't use EXEC_NOW!
int             trap_FS_FOpenFile(const char *qpath, fileHandle_t * f, fsMode_t mode);
void            trap_FS_Read(void *buffer, int len, fileHandle_t f);
void            trap_FS_Write(const void *buffer, int len, fileHandle_t f);
void            trap_FS_FCloseFile(fileHandle_t f);
int             trap_FS_GetFileList(const char *path, const char *extension, char *listbuf, int bufsize);
int             trap_FS_Seek(fileHandle_t f, long offset, int origin);	// fsOrigin_t
qhandle_t       trap_R_RegisterModel(const char *name, qboolean forceStatic);
qhandle_t       trap_R_RegisterSkin(const char *name);
qhandle_t       trap_R_RegisterShaderNoMip(const char *name);
void            trap_R_ClearScene(void);
void            trap_R_AddRefEntityToScene(const refEntity_t * re);
void            trap_R_AddPolyToScene(qhandle_t hShader, int numVerts, const polyVert_t * verts);
void            trap_R_AddLightToScene(const vec3_t org, float intensity, float r, float g, float b);
void            trap_R_RenderScene(const refdef_t * fd);
void            trap_R_SetColor(const float *rgba);
void            trap_R_DrawStretchPic(float x, float y, float w, float h, float s1, float t1, float s2, float t2,
									  qhandle_t hShader);
void            trap_R_DrawRotatedPic(float x, float y, float w, float h, float s1, float t1, float s2, float t2,
									  qhandle_t hShader, float angle);
void            trap_R_ModelBounds(clipHandle_t model, vec3_t mins, vec3_t maxs);
void            trap_UpdateScreen(void);
int             trap_CM_LerpTag(orientation_t * tag, clipHandle_t mod, int startFrame, int endFrame, float frac,
								const char *tagName);
void            trap_S_StartLocalSound(sfxHandle_t sfx, int channelNum);
sfxHandle_t     trap_S_RegisterSound(const char *sample, qboolean compressed);
void            trap_Key_KeynumToStringBuf(int keynum, char *buf, int buflen);
void            trap_Key_GetBindingBuf(int keynum, char *buf, int buflen);
void            trap_Key_SetBinding(int keynum, const char *binding);
qboolean        trap_Key_IsDown(int keynum);
qboolean        trap_Key_GetOverstrikeMode(void);
void            trap_Key_SetOverstrikeMode(qboolean state);
void            trap_Key_ClearStates(void);
int             trap_Key_GetCatcher(void);
void            trap_Key_SetCatcher(int catcher);
void            trap_GetClipboardData(char *buf, int bufsize);
void            trap_GetClientState(uiClientState_t * state);
void            trap_GetGlconfig(glconfig_t * glconfig);
void            trap_GetGlconfig2(glconfig2_t * glconfig);
int             trap_GetConfigString(int index, char *buff, int buffsize);
int             trap_LAN_GetServerCount(int source);
void            trap_LAN_GetServerAddressString(int source, int n, char *buf, int buflen);
void            trap_LAN_GetServerInfo(int source, int n, char *buf, int buflen);
int             trap_LAN_GetServerPing(int source, int n);
int             trap_LAN_GetPingQueueCount(void);
void            trap_LAN_ClearPing(int n);
void            trap_LAN_GetPing(int n, char *buf, int buflen, int *pingtime);
void            trap_LAN_GetPingInfo(int n, char *buf, int buflen);
void            trap_LAN_LoadCachedServers(void);
void            trap_LAN_SaveCachedServers(void);
void            trap_LAN_MarkServerVisible(int source, int n, qboolean visible);
int             trap_LAN_ServerIsVisible(int source, int n);
qboolean        trap_LAN_UpdateVisiblePings(int source);
int             trap_LAN_AddServer(int source, const char *name, const char *addr);
void            trap_LAN_RemoveServer(int source, const char *addr);
void            trap_LAN_ResetPings(int n);
int             trap_LAN_ServerStatus(const char *serverAddress, char *serverStatus, int maxLen);
int             trap_LAN_CompareServers(int source, int sortKey, int sortDir, int s1, int s2);
int             trap_MemoryRemaining(void);
void            trap_R_RegisterFont(const char *pFontname, int pointSize, fontInfo_t * font);
void            trap_S_StopBackgroundTrack(void);
void            trap_S_StartBackgroundTrack(const char *intro, const char *loop);
int             trap_CIN_PlayCinematic(const char *arg0, int xpos, int ypos, int width, int height, int bits);
e_status        trap_CIN_StopCinematic(int handle);
e_status        trap_CIN_RunCinematic(int handle);
void            trap_CIN_DrawCinematic(int handle);
void            trap_CIN_SetExtents(int handle, int x, int y, int w, int h);
int             trap_RealTime(qtime_t * qtime);
void            trap_R_RemapShader(const char *oldShader, const char *newShader, const char *timeOffset);

//
// ui_addbots.c
//
void            UI_AddBots_Cache(void);
void            UI_AddBotsMenu(void);

//
// ui_removebots.c
//
void            UI_RemoveBots_Cache(void);
void            UI_RemoveBotsMenu(void);

//
// ui_teamorders.c
//
extern void     UI_TeamOrdersMenu(void);
extern void     UI_TeamOrdersMenu_f(void);
extern void     UI_TeamOrdersMenu_Cache(void);

//
// ui_loadconfig.c
//
void            UI_LoadConfig_Cache(void);
void            UI_LoadConfigMenu(void);

//
// ui_saveconfig.c
//
void            UI_SaveConfigMenu_Cache(void);
void            UI_SaveConfigMenu(void);

//
// ui_display.c
//
void            UI_DisplayOptionsMenu_Cache(void);
void            UI_DisplayOptionsMenu(void);

//
// ui_sound.c
//
void            UI_SoundOptionsMenu_Cache(void);
void            UI_SoundOptionsMenu(void);

//
// ui_network.c
//
void            UI_NetworkOptionsMenu_Cache(void);
void            UI_NetworkOptionsMenu(void);

//
// ui_gameinfo.c
//
typedef enum
{
	AWARD_ACCURACY,
	AWARD_IMPRESSIVE,
	AWARD_EXCELLENT,
	AWARD_GAUNTLET,
	AWARD_FRAGS,
	AWARD_PERFECT
} awardType_t;

const char     *UI_GetArenaInfoByNumber(int num);
const char     *UI_GetArenaInfoByMap(const char *map);
const char     *UI_GetSpecialArenaInfo(const char *tag);
int             UI_GetNumArenas(void);
int             UI_GetNumSPArenas(void);
int             UI_GetNumSPTiers(void);

char           *UI_GetBotInfoByNumber(int num);
char           *UI_GetBotInfoByName(const char *name);
int             UI_GetNumBots(void);
void            UI_LoadBots(void);
char           *UI_GetBotNameByNumber(int num);

void            UI_GetBestScore(int level, int *score, int *skill);
void            UI_SetBestScore(int level, int score);
int             UI_TierCompleted(int levelWon);
qboolean        UI_ShowTierVideo(int tier);
qboolean        UI_CanShowTierVideo(int tier);
int             UI_GetCurrentGame(void);
void            UI_NewGame(void);
void            UI_LogAwardData(int award, int data);
int             UI_GetAwardLevel(int award);

void            UI_SPUnlock_f(void);
void            UI_SPUnlockMedals_f(void);

void            UI_InitGameinfo(void);

//
// ui_login.c
//
void            Login_Cache(void);
void            UI_LoginMenu(void);

//
// ui_signup.c
//
void            Signup_Cache(void);
void            UI_SignupMenu(void);

//
// ui_rankstatus.c
//
void            RankStatus_Cache(void);
void            UI_RankStatusMenu(void);


// new ui

#define ASSET_BACKGROUND "uiBackground"

// for tracking sp game info in Team Arena
typedef struct postGameInfo_s
{
	int             score;
	int             redScore;
	int             blueScore;
	int             perfects;
	int             accuracy;
	int             impressives;
	int             excellents;
	int             defends;
	int             assists;
	int             gauntlets;
	int             captures;
	int             time;
	int             timeBonus;
	int             shutoutBonus;
	int             skillBonus;
	int             baseScore;
} postGameInfo_t;

// for credits
typedef struct creditRow_s
{
	const char     *name;
	const char     *location;
	const char     *component;
	const char     *tasks;
} creditRow_t;

#endif
